Orientation in RStudio

Here’s a picture of the layout that you’ll see. There are “panes”, and a number of windows that you should be familiar with first. Note that in each “pane” there are some tabs that can change the content of the pane.

1. Source Editor - This is the place you’ll be writing “scripts”. If you’re writing code that you will want to save into a file, this is where you would do that. You can think of this as just a text file, with a special extension “.R” so that your computer knows that the text that is contained in the file is actually R code.
2. Console - If you want to actually RUN R code, this is where you’ll enter it. The > is important. The greater than symbol means that R is “ready for a new command”. If you don’t see this (a + or something), hit Esc until you see it again. Note that things you enter directly in the console will not be saved. We normally would use this for one-off calculations, or looking at parts of our code interactively.
3. Environment - This area will have all the variables that we’ve saved, that R knows about. When we learn about assignment later, you will see them show up here. This provides information about the name and the type of variable it is.
4. Files/Plots/Help/etc - This area is important because you can navigate your computer files here. You can also see a list of “packages” that R has loaded. Finally, if you make any plots, or ask R for help, they will appear in this pane.

Here’s the workflow I would recommend to get started.

1. Open up a new script in File > New File > R Script.
2. Save the empty file somewhere you on your computer that is appropriate.
3. Type all your code in the source editor, then use the “Run” button to transfer that line down into the console.
4. Examine the console for the result of running that R code
5. Save often!

Calculator in R

The basic mathematical operations in R will behave as you expect. I won’t show the output of everything I type, I just hope you’ll copy and paste things into the console of things you’re not sure about to confirm them for yourself.

1 + 1 # You can add comments after statements too. R will run "1 + 1" but ingore everything else
2 * 2
5 / 2
3^3 # 3 raised to the power of 3
exp(3) # e^3 where e is Euler's number
log(100) # natural log
21 %% 5 # remainder when divided by 5
2 + 4 * (3 + 5)^2 # Follows normal order of operations

Logical (True and False)

True and False can be specified as:

• TRUE or T
• FALSE or F

These come with what are called “boolean operators”, essentially mathematical operations on logical values. TRUE and FALSE are also known as boolean values. For example:

• & - logical “and”
• | - logical “or” (this is a vertical bar, or pipe, normally found above the backslash character \)
• ! - logical “not”
• xor() - logical “exclusive or”

Each of these correspond pretty well to what they mean in the english language.Imagine I say:

“I’m either a statistician OR a circus performer.”

At least one of those would need to be true in order for that statement to be factual. Hence all of T | T, T | F and F | T will evaluate to TRUE. The only way for that statement to be a lie would be for both to be false, which is why F | F evaluates to FALSE. Exclusive Or xor() is a special case in which instead of at least one, we require EXACTLY one to be true in order to evaluate to true. The “not” ! statement will reverse the logical value.

Now we can compare numbers, and have them evaluate to logical values. Most computing languages have this so it’s easier to control the flow of programs. “Run this chunk of code conditional on whether or not something is true”.

!TRUE # FALSE
TRUE | FALSE # TRUE
TRUE & FALSE # FALSE
?logical
?`&`

5 > 3 # 5 is greater than 3, TRUE
2 >= 2 # 2 is indeed greater than or equal to 2, TRUE
4 != 3 # 4 is not equal to 3


is.logical(FALSE) # TRUE
is.logical(1) # FALSE
is.numeric(1) # TRUE
?is.logical
?is.numeric

The last three are some special functions that allow us to ask R, what type of objects are we dealing with here, and R will tell us yes or no. This is also our first example of a function that we deal with. We will cover these in more depth a little later in the functions section.

Vectors

This is how we deal with multiple values at once, in the same object. Since we often deal with multiple numbers at once, this will make it much easier to process them! R makes it very easy for us to apply some function to an entire list of numbers. For example, if we want to take the logarithm of a bunch of numbers, we can just call the function on that vector instead of each individually.

We say that the operation is “vectorized” if the function will act on each of the elements individually.

The syntax to create a “vector” of things, is c(2, 3, 4), which will combine the numbers 2, 3, and 4 into one object. The c() stands for “combine”.

c(1, 2, 3, 4, 5, 6, 7) # Vector of numerics
c(TRUE, FALSE, TRUE) # Vector of logicals

c(c(1, 3, 4), c(2, 3, 4)) # even combine multiple vectors into 1

log(c(1, 2, 3, 4, 5)) # log elementwise
c(1, 2, 3) + c(2, 2, 2) # Adds the numbers elementwise
c(1, 2, 3)^2 # squares each number

As you can see, having functions that vectorize like this can be very powerful. However, there are somethings to be careful of!

Try to keep everything of the same “type” in a vector, otherwise, the logical value will be forced into a number like the rest of the elements. R will try to be smart about how it forces these values into different types, so R will rarely show an error or warning when doing so. Generally this causes more pain than it is helpful for, so for your own sake, keep things consistent!

c(2, 3, 4, FALSE)

Also, there is a “feature” in R called recycling, in which if we try to add two vectors of different lengths, R will start recyling the shorter one, that is, if it runs out, it will loop back to the first number and cycle through the vector again. Note sometimes R will throw out a warning message, but sometimes it will not (when the lengths are multiples of each other).

?c()
c(1, 2) + c(1, 1, 1) # warning
c(1, 2) + c(1, 1, 1, 1) # No warning

Since creating these sequences of numbers such as integers between 2 and 100 is very common, there is a shortcut to create that instead of c(2, 3, 4, 5, 6, 7, ...) by using a colon syntax 2:100. This means I want all integers between 2 and 100.

The other way to create sequences is with the function seq(2, 100, 1). The syntax of this function is seq(FROM, TO, BY). From what number, to what number, and by how much in between.

1:10 # 1-10
5:1 # Even works backwards
-6:6 # Through negative numbers too
1.5:10.9 # For decimals, it keeps them spaced by 1

seq(0, 1, .05) # Evenly spaced by .05
seq(6, 1, -1.2) # Notice the BY spacing should match the direction of the sequence
?seq()

Assignment

We now learn how to save things into variable names. At the heart of it, that’s really it, variable assignment is really just giving a statement a name (ideally easy for you to remember). It would not be very helpful if we ran some sort of calculation, and needed to reference that calculation later, but end up needing to run the entire caclulation again.

There are two common ways of making an assignment.

• <- - This is a less than sign, then and a minus sign. Notice that there is NO SPACE BETWEEN THE TWO CHARACTERS
• = - This is way of assigning variables in most other programming languages.

It really doesn’t matter which you use. I think among those that use R, it’s split about 50-50. So when looking at other people’s code, it’s good to know. What I don’t recommend is mixing them. I prefer the <-, so that’s what you’ll see me use. For those curious, there is a keyboard shortcut to help type the assignment, it’s Option + -.

Naming convention is to use alphanumeric names with underscores (a-zA-Z0-9). R will allow you to use a . as well, but I would recommend against this, since names with . are commonly used with the S3 method system. Plus, it’s confusing because . is normally a special character in most other languages. If you want to name something with multiple words, either use camelCase or snake_variable_naming. Capitalization matters

a <- 3
b <- 4
A <- 1 # Capitalization matters with naming!!
a + b
A + b

a <- a + 1
a + b

myVector <- 1:5
exp(myVector)

Functions

This is a big one. Most everything you deal with in R will be a function, so it’s important to understand the rules of these beasts.

Functions normally look like this nameOfTheFunction(...), with some variable name followed by paired parentheses. The things inside the parentheses are called “arguments”. These are values or objects that either modify how the function is run, or something you want the function to process for you.

The logarithm that we used before was a function. log(5) will take the “natural log” of whatever you pass within the parentheses. Now R just assumed we wanted the natural log because that’s probably what is most common in mathematics. However, there must be some way of modifying this behavior. Looking at ?log, we see some related functions, and a section for “Usage”

Usage

log(x, base = exp(1))

Arguments

x : a numeric or complex vector.

base : a positive or complex number: the base with respect to which logarithms are computed. Defaults to e=exp(1).

To explain this in a little more detail, we can see that log is designed to actually take 2 arguments. The first is a number (or vector) that we wish to take the log of. The second argument is named and optional. It’s named, base, and it’s optional because we can see that R by default sets it to exp(1), which is the Euler number, and thus natural log. If we don’t specify anything R will use the default.

?log
log(3) # Assumes natural log
log(10, 10) # The second argument R will read as the "base"
log(10, base = 10) # We can also specify arguments by it's name explicitly.

Seeing above, we can other specify arguments “positionally” or “by name”. Specifying arguments by name is useful because if you ever encounter a function with MANY optional arguments, but we only needed to modify one of them, specifying by name allows us to just select out the one we wish to use, without having to count the position of the argument.

# Personal function to calculate the power of a number
myPower <- function(x = 2, p = 2) {
  x^p
}

myPower(5,3) # 5^3 = 125
myPower(5) # 25, specify the "x" argument positionally, while default power is 2
myPower() # 4, All arguments are optional
myPower(p = 3) # 8, Specify second argument by name

Basic

The plot function takes two main arguments, x and y that are both required. Somewhat intuitively, they are the coordinates of the the points you want to plot. The first number in vector x is matched with the first in vector y, the second with second, etc…

plot(c(1,2,3), c(4, 0, -2)) # Plots points (1,2), (2, 0), and (3, -2)

We learned that many functions in R “vectorize” meaning you can apply them to each individual element of a vector very quickly. Plotting functions is a great illustration of how this can be useful.

x <- seq(-3, 3, .25)
y <- x^2
plot(x,y)

?plot

Plot Options

Now we know that we’re plotting a parabola, but instead of plotting the points, we may want to connect the dots with a line, we can do this with the optional argument type="l", where the "l" stands for line.

plot(x, y, type="l")

?plot.default
?plot.xy
# Uncomment the line below, and run the command to see all the colors available in R
# colors()

In fact, there are loads of options to modify how the plot looks, labels on x and y axis, title, color, type of plot, limits of axes, etc.

• col= change colors of plot, can be vector for multiple colors, run colors() for all options, or see pdf
• type=c("p", "l", "b", "c", "o", "h", "s", "S", "n") Change the type of plot
  • points
  • lines
  • both
  • c for lines part
  • o for “overplotted”.
  • histogram, vertical lines
  • stair steps
  • S different type of stair steps
  • n for no plotting.
• xlim=c(LEFT_LIMIT, RIGHT_LIMIT) boundaries of shown x-axis
• ylim=c(LOWER_LIMIT, UPPER_LIMIT) boundaries of shown y-axis
• main="TITLE_OF_PLOT" overall title of overall plot
• sub="SUBTITLE_OF_PLOT" subtitle of overall plot
• xlab="X_AXIS_LABEL" label for x-axis
• ylab="Y_AXIS_LABEL" label for y-axis
• lwd=WIDTH numerical width of a line (when using a line plot) Graphical Parameters
• lty=TYPE_OF_LINE numerical code of dashed/solid or some variant style of line Graphical Parameters
• pch=c(0:25, *, ., o, O, 0, +, -, |, %, #) numerical code to modify symbol of point for point plots Graphical Parameters

For example, here’s what an option filled plot would look like,

plot(x, y, col="red", type="l", lty=2, lwd=3, xlab="Error", ylab="Penalty", main="Example Title", sub="The subtitle")

Legend